home *** CD-ROM | disk | FTP | other *** search
/ Visual Basic Source Code / Visual Basic Source Code.iso / vbsource / mcomm / xyzgen.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-10-02  |  13.8 KB  |  364 lines
  1.  
  2. /*/////////////////////////////////////////////////////////////////////
  3. //                                                                   //
  4. //  XYZGEN.C -- functions common to xmodem, ymodem, zmodem           //
  5. //                                                                   //
  6. //    (c) 1991, Mike Dumdei, 6 Holly Lane, Texarkana TX, 75503       //
  7. //                                                                   //
  8. //////////////////////////////////////////////////////////////////// */
  9. #include <stdio.h>
  10. #include <string.h>
  11. #include <stdlib.h>
  12. #include <dos.h>
  13. #include <bios.h>
  14. #include "comm.h"
  15. #include "extra.h"
  16. #include "zmdos.h"
  17. #ifdef __TURBOC__
  18.   #include <dir.h>
  19. #endif
  20.  
  21. /*--------------------------------------------------------------------+
  22. |                                                                     |
  23. |                             Data Section                            |
  24. |                                                                     |
  25. +--------------------------------------------------------------------*/
  26. #define GLOBAL
  27. /*--------------------------------------------+
  28. |  initialized globals used by x,y,zmodem     |
  29. +--------------------------------------------*/
  30. GLOBAL ASYNC *tPort = NULL;     /* pointer to port structure */
  31. GLOBAL char *DfltPath = "";     /* default download path */
  32. GLOBAL long ConnectBaud = 0L;   /* set to connect rate if using fixed link */
  33. GLOBAL int RxTimeOut = 182;     /* receive char timeout in ticks (1/18 s.) */
  34. GLOBAL int DefRxTimeOut = 182;  /* default value for RxTimeOut */
  35. GLOBAL int VBufSize = 2048;     /* size of variable disk buffer to use */
  36. GLOBAL WORD BufSize = 0;        /* 0 if overlaying I/O, else <= VBufSize */
  37. GLOBAL TFLAGS TFlag = { 0x29 }; /* transfer flags (resume,keeptime,ign car) */
  38.  
  39. /*--------------------------------------------+
  40. |  uninitialized globals used by x,y,zmodem   |
  41. +--------------------------------------------*/
  42. GLOBAL char *PathName = NULL;   /* full pathname of current file */
  43. GLOBAL char *NameExt = NULL;    /* name and extension only of current file */
  44. GLOBAL long FilePos = 0L;       /* current file offset */
  45. GLOBAL long FileSize = 0L;      /* length of current file */
  46. GLOBAL int BlkLen = 0;          /* current block length */
  47. GLOBAL int BytesRxd = 0;        /* # bytes in last data packet received */
  48. GLOBAL BYTE *IOBuf = NULL;      /* I/O buffer */
  49. GLOBAL BYTE RxQueue[128] = "";  /* receive queue */
  50. GLOBAL BYTE *RxQPtr = NULL;     /* pointer to current RxQueue position */
  51. GLOBAL int RxBytesQd = 0;       /* bytes in receive queue */
  52.  
  53. /*--------------------------------------------+
  54. |  static variables                           |
  55. +--------------------------------------------*/
  56. static FILE *tFh = NULL;        /* file handle of current file */
  57. static BYTE *VBuf = NULL;       /* buffer for setvbuf */
  58. static int XoffFlow = 0;        /* XOFF flow control active */
  59. static int CTSFlow = B_CTS;     /* CTS flow control inactive (CTS high) */
  60.  
  61. /*--------------------------------------------+
  62. |  16 bit CRC table                           |
  63. +--------------------------------------------*/
  64. GLOBAL WORD Crc16Tbl[256] =
  65. {
  66.     0x0000, 0x1021, 0x2042, 0x3063, 0x4084, 0x50A5, 0x60C6, 0x70E7, 
  67.     0x8108, 0x9129, 0xA14A, 0xB16B, 0xC18C, 0xD1AD, 0xE1CE, 0xF1EF, 
  68.     0x1231, 0x0210, 0x3273, 0x2252, 0x52B5, 0x4294, 0x72F7, 0x62D6, 
  69.     0x9339, 0x8318, 0xB37B, 0xA35A, 0xD3BD, 0xC39C, 0xF3FF, 0xE3DE, 
  70.     0x2462, 0x3443, 0x0420, 0x1401, 0x64E6, 0x74C7, 0x44A4, 0x5485, 
  71.     0xA56A, 0xB54B, 0x8528, 0x9509, 0xE5EE, 0xF5CF, 0xC5AC, 0xD58D, 
  72.     0x3653, 0x2672, 0x1611, 0x0630, 0x76D7, 0x66F6, 0x5695, 0x46B4, 
  73.     0xB75B, 0xA77A, 0x9719, 0x8738, 0xF7DF, 0xE7FE, 0xD79D, 0xC7BC, 
  74.     0x48C4, 0x58E5, 0x6886, 0x78A7, 0x0840, 0x1861, 0x2802, 0x3823, 
  75.     0xC9CC, 0xD9ED, 0xE98E, 0xF9AF, 0x8948, 0x9969, 0xA90A, 0xB92B, 
  76.     0x5AF5, 0x4AD4, 0x7AB7, 0x6A96, 0x1A71, 0x0A50, 0x3A33, 0x2A12, 
  77.     0xDBFD, 0xCBDC, 0xFBBF, 0xEB9E, 0x9B79, 0x8B58, 0xBB3B, 0xAB1A, 
  78.     0x6CA6, 0x7C87, 0x4CE4, 0x5CC5, 0x2C22, 0x3C03, 0x0C60, 0x1C41, 
  79.     0xEDAE, 0xFD8F, 0xCDEC, 0xDDCD, 0xAD2A, 0xBD0B, 0x8D68, 0x9D49, 
  80.     0x7E97, 0x6EB6, 0x5ED5, 0x4EF4, 0x3E13, 0x2E32, 0x1E51, 0x0E70, 
  81.     0xFF9F, 0xEFBE, 0xDFDD, 0xCFFC, 0xBF1B, 0xAF3A, 0x9F59, 0x8F78, 
  82.     0x9188, 0x81A9, 0xB1CA, 0xA1EB, 0xD10C, 0xC12D, 0xF14E, 0xE16F, 
  83.     0x1080, 0x00A1, 0x30C2, 0x20E3, 0x5004, 0x4025, 0x7046, 0x6067, 
  84.     0x83B9, 0x9398, 0xA3FB, 0xB3DA, 0xC33D, 0xD31C, 0xE37F, 0xF35E, 
  85.     0x02B1, 0x1290, 0x22F3, 0x32D2, 0x4235, 0x5214, 0x6277, 0x7256, 
  86.     0xB5EA, 0xA5CB, 0x95A8, 0x8589, 0xF56E, 0xE54F, 0xD52C, 0xC50D, 
  87.     0x34E2, 0x24C3, 0x14A0, 0x0481, 0x7466, 0x6447, 0x5424, 0x4405, 
  88.     0xA7DB, 0xB7FA, 0x8799, 0x97B8, 0xE75F, 0xF77E, 0xC71D, 0xD73C, 
  89.     0x26D3, 0x36F2, 0x0691, 0x16B0, 0x6657, 0x7676, 0x4615, 0x5634, 
  90.     0xD94C, 0xC96D, 0xF90E, 0xE92F, 0x99C8, 0x89E9, 0xB98A, 0xA9AB, 
  91.     0x5844, 0x4865, 0x7806, 0x6827, 0x18C0, 0x08E1, 0x3882, 0x28A3, 
  92.     0xCB7D, 0xDB5C, 0xEB3F, 0xFB1E, 0x8BF9, 0x9BD8, 0xABBB, 0xBB9A, 
  93.     0x4A75, 0x5A54, 0x6A37, 0x7A16, 0x0AF1, 0x1AD0, 0x2AB3, 0x3A92, 
  94.     0xFD2E, 0xED0F, 0xDD6C, 0xCD4D, 0xBDAA, 0xAD8B, 0x9DE8, 0x8DC9, 
  95.     0x7C26, 0x6C07, 0x5C64, 0x4C45, 0x3CA2, 0x2C83, 0x1CE0, 0x0CC1, 
  96.     0xEF1F, 0xFF3E, 0xCF5D, 0xDF7C, 0xAF9B, 0xBFBA, 0x8FD9, 0x9FF8, 
  97.     0x6E17, 0x7E36, 0x4E55, 0x5E74, 0x2E93, 0x3EB2, 0x0ED1, 0x1EF0
  98. };
  99.  
  100. /*--------------------------------------------------------------------+
  101. |                                                                     |
  102. |                             Code Section                            |
  103. |                                                                     |
  104. +--------------------------------------------------------------------*/
  105.  
  106. /*/////////////////////////////////////////////////////////
  107. //  AsyncMode - save/set/restore async mode of operation //
  108. /////////////////////////////////////////////////:async: */
  109. void _C_ AsyncMode(int mode)
  110. {
  111.     static char params[10];
  112.     static BYTE xmode, modeset = 0;
  113.     char *n_params;
  114.     BYTE n_xmode;
  115.  
  116.     if (mode != 0)                  /* 1 = xflow, 2 = no xflow */
  117.     {                               /*  both 1 & 2 set "N81"   */
  118.         if (modeset == 0)
  119.         {
  120.             xmode = tPort->Stat3 & (B_XUSET | B_XUSER);
  121.             strcpy(params, tPort->BPDSstr);
  122.             ++modeset;
  123.         }
  124.         n_xmode = (mode == 1) ? B_XUSE : 0;
  125.         strcpy((strchr(n_params = tPort->BPDSstr, '\0') - 3), "N81");
  126.     }
  127.     else
  128.     {
  129.         if (modeset == 0)
  130.             return;
  131.         --modeset;
  132.         n_xmode = xmode;            /* restore configuration   */
  133.         n_params = params;
  134.     }
  135.     async_xflow(tPort, n_xmode);
  136.     async_setbpds(tPort, n_params);
  137. }
  138.  
  139. /*/////////////////////////////////////////////////////////
  140. //  Blk16Crc - calculates 16 bit crc for a block of bytes//
  141. //   returns: 16 bit crc                                 //
  142. ///////////////////////////////////////////////////:crc: */
  143. WORD _C_ Blk16Crc(register BYTE *block, int bytes)
  144. {
  145.     register WORD crc = 0;
  146.  
  147.     while (bytes--)
  148.         crc = Upd16Crc(crc, *block++);
  149.     return (crc);
  150. }
  151.  
  152. /*/////////////////////////////////////////////////////////
  153. //  CloseFile -- close disk file                         //
  154. //   statics: VBuf, tFh                                  //
  155. //////////////////////////////////////////////////:disk: */
  156. void _C_ CloseFile(void)
  157. {
  158.     if (tFh == NULL)
  159.         return;
  160.     if (TFlag.F.Receiving && TFlag.F.KeepTime)
  161.     {
  162.         fflush(tFh);
  163.         UnixToDos(&DosTime, &DosDate, RxdUnixTime);
  164.         DosSetFileTime(fileno(tFh), DosDate, DosTime);
  165.     }
  166.     fclose(tFh);
  167.     tFh = NULL;
  168.     if (VBuf != NULL)
  169.         free(VBuf), VBuf = NULL;
  170. }
  171.  
  172. /*/////////////////////////////////////////////////////////
  173. //  FlushDisk -- flush file buffers                      //
  174. //////////////////////////////////////////////////:disk: */
  175. void _C_ FlushDisk(void)
  176. {
  177.     fflush(tFh);
  178. }
  179.  
  180. /*/////////////////////////////////////////////////////////
  181. //  GetNameExt -- get pointer to file name.ext component //
  182. //   returns: pointer to name.ext                        //
  183. /////////////////////////////////////////////////:parse: */
  184. char * _C_ GetNameExt(char *FullPath)
  185. {
  186.     register char *p1 = strchr(FullPath, '\0');
  187.     while (p1-- > FullPath)
  188.     {
  189.         if (*p1 == '\\' || *p1 == ':' || *p1 == '/')
  190.             break;
  191.     }
  192.     return (++p1);
  193. }
  194.  
  195. /*/////////////////////////////////////////////////////////
  196. //  LoadRxQueue - block receive with time out            //
  197. //   returns: received character, fatal error, TIMED_OUT //
  198. /////////////////////////////////////////////////:async: */
  199. int _C_ LoadRxQueue(void)
  200. {
  201.     long rxtimer, xontimer;
  202.  
  203.     RxQPtr = RxQueue;
  204.     if (!async_rxcnt(tPort))
  205.     {
  206.         set_timeout(&rxtimer, RxTimeOut);
  207.         set_timeout(&xontimer, XonTimeOut);
  208.     }
  209.     while (1)
  210.     {
  211.         ZMsg(M_IDLE);
  212.         if (KBHIT && ((KBREAD & 0xff) == 0x1b))
  213.             return LCL_ABORT;
  214.         if (!async_carrier(tPort) && !TFlag.F.IgnCarrier)
  215.             return LOST_CARRIER;
  216.         if ((RxBytesQd =
  217.          async_rxblk(tPort, (char *)RxQueue, sizeof(RxQueue))-1) >= 0)
  218.             return (*RxQPtr++);
  219.         if (timed_out(&rxtimer))
  220.             return TIMED_OUT;
  221.         if (async_xuse(tPort) && timed_out(&xontimer))
  222.         {
  223.             async_tx(tPort, XON);
  224.             set_timeout(&xontimer, XonTimeOut);
  225.         }
  226.     }
  227. }
  228.  
  229. /*/////////////////////////////////////////////////////////
  230. //  OpenFile -- open disk file                           //
  231. //   returns: 1 if file opened, 0 if open failed         //
  232. //   statics: tFh, VBuf                                  //
  233. //////////////////////////////////////////////////:disk: */
  234. int _C_ OpenFile(char *name, char *mode)
  235. {
  236.     if ((tFh = fopen(name, mode)) == NULL)
  237.         return 0;
  238.     if (VBufSize > 512 && (VBuf = malloc(VBufSize)) != NULL)
  239.         setvbuf(tFh, (char *)VBuf, _IOFBF, VBufSize);
  240.     return 1;
  241. }
  242.  
  243. /*/////////////////////////////////////////////////////////
  244. //  ReadDisk -- read disk block padding with ctrl-z's    //
  245. //   returns: number of bytes read                       //
  246. //////////////////////////////////////////////////:disk: */
  247. int _C_ ReadDisk(int bytes)
  248. {
  249.     int i;
  250.  
  251.     if ((i = fread(IOBuf, 1, bytes, tFh)) < bytes)
  252.     {
  253.         if (!feof(tFh))
  254.             return FILE_ERR;
  255.         memset(&IOBuf[i], '\x1a', bytes - i);
  256.     }
  257.     return (i);
  258. }
  259.  
  260. /*/////////////////////////////////////////////////////////
  261. //  Seek -- seek to file position                        //
  262. //   returns: 0 if success, else FILE_ERR                //
  263. //////////////////////////////////////////////////:disk: */
  264. int _C_ Seek(long pos)
  265. {
  266.     return ((fseek(tFh, pos, SEEK_SET) == 0) ? 0 : FILE_ERR);
  267. }
  268.  
  269. /*/////////////////////////////////////////////////////////
  270. //  SendBreak - send ~100 ms break signal                //
  271. /////////////////////////////////////////////////:async: */
  272. void _C_ SendBreak(void)
  273. {
  274.     Delay(1);
  275.     async_sndbrk(tPort, 1);
  276.     Delay(2);
  277.     async_sndbrk(tPort, 0);
  278. }
  279.  
  280. /*/////////////////////////////////////////////////////////
  281. //  WaitTxLevel - monitor transmit buffer level          //
  282. //   returns: 1 = transmit buffer <= level               //
  283. //            0 = transmit buffer > level                //
  284. //   generates M_IDLE ZMsg if still waiting              //
  285. //   generates M_FLOW ZMsgs with following args:         //
  286. //            0 - delta XOFF (XOFF cleared)              //
  287. //            1 - delta XOFF (got an XOFF)               //
  288. //            2 - delta CTS (ok to send)                 //
  289. //            3 - delta CTS (flow control enabled)       //
  290. //            4 - port error (port restarted)            //
  291. /////////////////////////////////////////////////////:z: */
  292. int _C_ WaitTxLevel(int level)
  293. {
  294.     static long xofftimer;
  295.     register int ch, count;
  296.     long ticks;
  297.  
  298.     if (((ch = async_cts(tPort)) ^ CTSFlow) && !(tPort->MSRMask & B_CTS))
  299.     {
  300.         ZMsg(M_FLOW, (ch) ? 2 : 3);
  301.         CTSFlow = ch;
  302.     }
  303.     if ((ch = async_xrxd(tPort)) ^ XoffFlow)
  304.         ZMsg(M_FLOW, (ch) ? 1 : 0);
  305.     if (ch)
  306.     {
  307.         if (XoffFlow == 0)
  308.             set_timeout(&xofftimer, XoffTimeOut);
  309.         else if (timed_out(&xofftimer))
  310.             async_xoffclr(tPort);
  311.     }
  312.     XoffFlow = ch;
  313.     if ((count = async_txcnt(tPort)) <= level)
  314.         return 1;
  315.     if (!async_carrier(tPort) && !TFlag.F.IgnCarrier)
  316.         return LOST_CARRIER;
  317.     if ((ch = KBHIT) != 0)
  318.     {
  319.         if ((ch & 0xff) == 0x1b)
  320.             return LCL_ABORT;
  321.         KBREAD;
  322.     }
  323.     set_timeout(&ticks, 4);
  324.     while ((count == async_txcnt(tPort)) && !async_xrxd(tPort)
  325.      && async_cts(tPort) && !timed_out(&ticks))
  326.         ;
  327.     if (timed_out(&ticks))
  328.     {
  329.         ZMsg(M_FLOW, 4);
  330.         async_restart(tPort);
  331.         return 1;
  332.     }
  333.     if (count <= level)
  334.         return 1;
  335.     ZMsg(M_IDLE);
  336.     return 0;
  337. }
  338.  
  339. /*/////////////////////////////////////////////////////////
  340. //  WriteDisk -- write disk block                        //
  341. //   returns: bytes written or FILE_ERR                  //
  342. //////////////////////////////////////////////////:disk: */
  343. int _C_ WriteDisk(int bytes)
  344. {
  345.     return (fwrite(IOBuf, 1, bytes, tFh) == bytes) ? bytes : FILE_ERR;
  346. }
  347.  
  348. /*/////////////////////////////////////////////////////////
  349. //  XYInitVars - init variables common to X,Y,Zmodem     //
  350. //   returns: 0 if successful, else MEM_ERR              //
  351. //////////////////////////////////////////////////////// */
  352. int _C_ XYInitVars(ASYNC *comport)
  353. {
  354.     tPort = comport;
  355.     if ((IOBuf = calloc(MAXPACKET + MAX_PATH + 50, 1)) == NULL)
  356.         return MEM_ERR;
  357.     PathName = (char *)&IOBuf[MAXPACKET + 44];
  358.     BlkLen = (TFlag.F.KBlocks) ? 1024 : 128;
  359.     tFh = NULL, VBuf = NULL;
  360.     RxBytesQd = XoffFlow = 0;
  361.     return 0;
  362. }
  363.  
  364.